3  Configuração do Ambiente de Desenvolvimento

Para trabalhar com LLMs, é necessário um ambiente robusto capaz de lidar com computação numérica intensiva (os tensores). Utilizaremos Python e PyTorch, o framework padrão da indústria para pesquisa em Deep Learning.

3.1 Pré-requisitos

  • Sistema Operacional: Linux (recomendado Ubuntu 20.04+) ou Windows com WSL2.
  • Hardware: GPU NVIDIA recomendada (com drivers CUDA instalados) para treinamento ou inferência eficiente.
  • Python: Versão 3.8 a 3.11.

3.2 Gerenciamento de Ambientes Virtuais

Nunca instale bibliotecas no ambiente global do Python. Utilize venv ou Conda.

# Criação do ambiente virtual (Linux/Mac)
# python3 -m venv .venv
# Ativação do ambiente
# source .venv/bin/activate

# No Windows (PowerShell):
python -m venv .venv
.\venv\Scripts\Activate.ps1

Exemplo simples em Python

print("Olá Mundo")

3.3 Instalação do PyTorch

A instalação do PyTorch depende da sua versão de CUDA. Visite pytorch.org para o comando exato. Abaixo, um exemplo padrão para CUDA 11.8:

# Instalação com suporte a GPU (NVIDIA)
pip install torch torchvision torchaudio 
  --index-url https://download.pytorch.org/whl/cu118

# Se você não possui GPU (apenas CPU - muito lento para LLMs):
# pip install torch torchvision torchaudio

3.4 Ecossistema Hugging Face

A biblioteca transformers da Hugging Face é a interface padrão para acessar modelos pré-treinados.

pip install transformers accelerate datasets torch
  • transformers: Carrega modelos e tokenizadores.
  • accelerate: Otimiza o treinamento e inferência em hardware variado (multi-GPU, mixed precision).
  • datasets: Facilita o download e processamento de grandes corpora de texto.

3.5 Script de Verificação (Sanity Check)

Crie um arquivo chamado check_env.py para validar se o PyTorch consegue acessar a GPU e se a biblioteca Transformers está funcional.

import torch
from transformers import pipeline

def check_environment():
    print("=== Verificação de Ambiente ===")
    
    # 1. Verificar Python e PyTorch
    print(f"PyTorch Version: {torch.__version__}")
    
    # 2. Verificar disponibilidade de CUDA (GPU)
    cuda_available = torch.cuda.is_available()
    print(f"CUDA Available: {cuda_available}")
    
    if cuda_available:
        print(f"GPU Device: {torch.cuda.get_device_name(0)}")
        print(f"VRAM: {torch.cuda.get_device_properties(0).total_memory 
            / 1e9:.2f} GB")
    else:
        print("AVISO: Executando em CPU. O desempenho será limitado.")

    # 3. Teste rápido de inferência com um modelo pequeno (GPT-2)
    print("\n=== Teste de Inferência (Hugging Face) ===")
    try:
        # Pipeline abstrai a complexidade de tokenização e modelo
        generator = pipeline('text-generation', model='gpt2', device=0 
            if cuda_available else -1)
        
        prompt = "The future of AI is"
        result = generator(prompt, max_length=30, max_new_tokens=30, num_return_sequences=1, 
            truncation=True)
        
        print(f"Prompt: {prompt}")
        print(f"Output: {result[0]['generated_text']}")
        print("\nSUCESSO: Ambiente configurado corretamente.")
        
    except Exception as e:
        print(f"""\nERRO: Falha ao carregar modelo ou executar inferência.
                  \nDetalhes: {e}""")

if __name__ == "__main__":
    check_environment()

Aqui estão alguns exemplos simples que ilustram conceitos básicos relacionados ao Transformer usando a biblioteca transformers da Hugging Face:

from transformers import AutoTokenizer, AutoModel
import torch

# Carregar tokenizer e modelo pré-treinado
model_name = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name)

# Texto de exemplo
text = "Transformers são incríveis para PLN!"

# Tokenização
inputs = tokenizer(text, return_tensors="pt")

# Obter embeddings do modelo
outputs = model(**inputs)
last_hidden_states = outputs.last_hidden_state

print(last_hidden_states.shape)  # (batch_size, sequence_length, hidden_size)
last_hidden_states

Este código mostra como carregar um modelo Transformer pré-treinado (BERT), tokenizar um texto e obter as representações internas (embeddings) do modelo.

Outro exemplo simples para usar um modelo Transformer para classificação de texto:

from transformers import pipeline

# Criar pipeline de classificação de sentimento
classifier = pipeline("sentiment-analysis")

# Classificar texto
result = classifier("Eu adoro aprender sobre Transformers!")
print(result)

Este exemplo usa um pipeline pronto para análise de sentimento, que internamente utiliza um modelo Transformer para classificar o texto.

NoteResumo

Configuramos um ambiente Python isolado, instalamos o PyTorch com suporte a CUDA e validamos a instalação executando um modelo GPT-2 básico.